.TH std::derived_from 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::derived_from \- std::derived_from

.SH Synopsis
   Defined in header <concepts>
   template< class Derived, class Base >

   concept derived_from =
       std::is_base_of_v<Base, Derived> &&                                \fI(since C++20)\fP

       std::is_convertible_v<const volatile Derived*, const volatile
   Base*>;

   The concept derived_from<Derived, Base> is satisfied if and only if Base is a class
   type that is either Derived or a public and unambiguous base of Derived, ignoring
   cv-qualifiers.

   Note that this behavior is different to std::is_base_of when Base is a private or
   protected base of Derived.

.SH Example


// Run this code

 #include <concepts>

 class A {};

 class B : public A {};

 class C : private A {};

 // std::derived_from == true only for public inheritance or exact same class
 static_assert(std::derived_from<B, B> == true);      // same class: true
 static_assert(std::derived_from<int, int> == false); // same primitive type: false
 static_assert(std::derived_from<B, A> == true);      // public inheritance: true
 static_assert(std::derived_from<C, A> == false);     // private inheritance: false

 // std::is_base_of == true also for private inheritance
 static_assert(std::is_base_of_v<B, B> == true);      // same class: true
 static_assert(std::is_base_of_v<int, int> == false); // same primitive type: false
 static_assert(std::is_base_of_v<A, B> == true);      // public inheritance: true
 static_assert(std::is_base_of_v<A, C> == true);      // private inheritance: true

 int main() {}

.SH See also

   is_base_of             checks if a type is derived from the other type
   \fI(C++11)\fP                \fI(class template)\fP
   is_convertible
   is_nothrow_convertible checks if a type can be converted to the other type
   \fI(C++11)\fP                \fI(class template)\fP
   (C++20)
